home *** CD-ROM | disk | FTP | other *** search
/ CU Amiga Super CD-ROM 24 / CU Amiga Magazine's Super CD-ROM 24 (1998)(EMAP Images)(GB)(Track 1 of 2)[!][issue 1998-07].iso / CUCD / Programming / SWI / source / src / pl-fmt.c < prev    next >
Encoding:
C/C++ Source or Header  |  1997-08-07  |  10.3 KB  |  475 lines
  1. /*  $Id: pl-fmt.c,v 1.25 1997/08/07 07:57:54 jan Exp $
  2.  
  3.     Copyright (c) 1990 Jan Wielemaker. All rights reserved.
  4.     See ../LICENCE to find out about your rights.
  5.     jan@swi.psy.uva.nl
  6.  
  7.     Purpose: Formated write
  8. */
  9.  
  10. /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
  11. Formatted output (Prolog predicates format/[1,2,3]).   One  day,  the  C
  12. source should also use format() to produce error messages, etc.
  13. - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
  14.  
  15. #include "pl-incl.h"
  16. #include "pl-ctype.h"
  17. extern int Output;
  18.  
  19. #define BUFSIZE     10240
  20. #define DEFAULT     (-1)
  21. #define SHIFT       { argc--; argv++; }
  22. #define NEED_ARG    { if ( argc <= 0 ) \
  23.               { ERROR("not enough arguments"); \
  24.               } \
  25.             }
  26. #define ERROR(fmt)    return warning("format/2: %s", fmt)
  27. #define ERROR1(fmt, a)    { char tp[50]; \
  28.               strcpy(tp, "format/2: "); \
  29.               strcat(tp, fmt); \
  30.               return warning(tp, a); \
  31.             }
  32. #define OUTSTRING(s)    { char *q = s; \
  33.               for(; *q; q++) OUTCHR(*q); \
  34.             }
  35. #define OUTCHR(c)    { if ( pending_rubber ) \
  36.                 buffer[index++] = (c); \
  37.               else \
  38.                 Put((Char)(c)); \
  39.               column = update_column(column, c); \
  40.             }
  41.  
  42. #define MAXRUBBER 100
  43.  
  44. struct rubber
  45. { int where;                /* where is rubber in output */
  46.   int size;                /* how big should it be */
  47.   Char pad;                /* padding character */
  48. };
  49.  
  50. #define format_predicates (GD->format.predicates)
  51.  
  52. forwards int    update_column(int, Char);
  53. forwards bool    do_format(const char *fmt, int argc, term_t argv);
  54. forwards void    distribute_rubber(struct rubber *, int, int);
  55. forwards void    emit_rubber(char *buf, int, struct rubber *, int);
  56.  
  57.         /********************************
  58.         *       PROLOG CONNECTION    *
  59.         ********************************/
  60.  
  61. word
  62. pl_format_predicate(term_t chr, term_t descr)
  63. { long c;
  64.   Procedure proc;
  65.   Symbol s;
  66.  
  67.   if ( !PL_get_long(chr, &c) || c < 0 || c > 255 )
  68.   { char *s;
  69.     
  70.     if ( PL_get_atom_chars(chr, &s) && s[0] && !s[1] )
  71.       c = s[0] & 0xff;
  72.     else
  73.       return warning("format_predicate/2: illegal character");
  74.   }
  75.  
  76.   if ( !get_procedure(descr, &proc, 0, GP_CREATE) )
  77.     fail;
  78.   if ( proc->definition->functor->arity == 0 )
  79.     return warning("format_predicate/2: predicate must have at least 1 argument");
  80.  
  81.   if ( !format_predicates )
  82.     format_predicates = newHTable(8);
  83.   
  84.   if ( (s = lookupHTable(format_predicates, (void *)c)) )
  85.     s->value = (word) proc;
  86.   else
  87.     addHTable(format_predicates, (void *)c, proc);
  88.  
  89.   succeed;
  90. }
  91.  
  92.  
  93. word
  94. pl_format(term_t fmt, term_t Args)
  95. { term_t argv;
  96.   int argc = 0;
  97.   char *f;
  98.   int rval;
  99.   term_t args = PL_copy_term_ref(Args);
  100.   
  101.   if ( !PL_get_chars(fmt, &f, CVT_ALL|BUF_RING) )
  102.     return warning("format/2: format is not an atom or string");
  103.  
  104.   if ( (argc = lengthList(args)) >= 0 )
  105.   { term_t head = PL_new_term_ref();
  106.     int n = 0;
  107.  
  108.     argv = PL_new_term_refs(argc);
  109.     while( PL_get_list(args, head, args) )
  110.       PL_put_term(argv+n++, head);
  111.   } else
  112.   { argc = 1;
  113.     argv = PL_new_term_refs(argc);
  114.  
  115.     PL_put_term(argv, args);
  116.   }
  117.   
  118.   rval = do_format(f, argc, argv);
  119.  
  120.   return rval;
  121. }
  122.  
  123.  
  124. word
  125. pl_format3(term_t stream, term_t fmt, term_t args)
  126. { streamOutput(stream, pl_format(fmt, args));
  127. }
  128.  
  129. #if O_C_FORMAT
  130.  
  131.         /********************************
  132.         *          C-CONNECTION        *
  133.         ********************************/
  134.  
  135. static bool
  136. vformat(fm, args)
  137. char *fm;
  138. va_list args;
  139. { 
  140. }
  141.  
  142.  
  143. bool
  144. format(char *fm, ...)
  145. { va_list args;
  146.   bool rval;
  147.  
  148.   va_start(args, fm);
  149.   rval = vformat(fm, args);
  150.   va_end(args);
  151.  
  152.   return rval;
  153. }
  154.  
  155. #endif /* O_C_FORMAT */
  156.  
  157.         /********************************
  158.         *       ACTUAL FORMATTING    *
  159.         ********************************/
  160.  
  161. static int
  162. update_column(int col, int c)
  163. { switch(c)
  164.   { case '\n':    return 0;
  165.     case '\t':    return (col + 1) | 0x7;
  166.     case '\b':    return (col <= 0 ? 0 : col - 1);
  167.     default:    return col + 1;
  168.   }
  169. }   
  170.  
  171.  
  172. static bool
  173. do_format(const char *fmt, int argc, term_t argv)
  174. { char buffer[BUFSIZE];            /* to store chars with tabs */
  175.   int index = 0;            /* index in buffer */
  176.   int column = currentLinePosition();    /* current output column */
  177.   int tab_stop = 0;            /* padded tab stop */
  178.   int pending_rubber = 0;        /* number of not-filled ~t's */
  179.   struct rubber rub[MAXRUBBER];
  180.   Symbol s;
  181.  
  182.   LockStream();
  183.  
  184.   while(*fmt)
  185.   { switch(*fmt)
  186.     { case '~':
  187.     { int arg = DEFAULT;        /* Numeric argument */
  188.                     /* Get the numeric argument */
  189.       if ( isDigit(*++fmt) )
  190.       { for( ; isDigit(*fmt); fmt++ )
  191.           arg = (arg == DEFAULT ? arg = *fmt - '0' : arg*10 + *fmt - '0');
  192.       } else if ( *fmt == '*' )
  193.       { NEED_ARG;
  194.         if ( PL_get_integer(argv, &arg) )
  195.         { SHIFT;
  196.         } else
  197.           ERROR("no or negative integer for `*' argument");
  198.         fmt++;
  199.       } else if ( *fmt == '`' )
  200.       { arg = *++fmt;
  201.         fmt++;
  202.       }
  203.         
  204.                     /* Check for user defined format */
  205.       if ( format_predicates &&
  206.            (s = lookupHTable(format_predicates, (Void)((long)*fmt))) )
  207.       { Procedure proc = (Procedure) s->value;
  208.         FunctorDef fdef = proc->definition->functor;
  209.         term_t av = PL_new_term_refs(fdef->arity);
  210.         char buf[BUFSIZE];
  211.         char *str = buf;
  212.         int i;
  213.         qid_t qid;
  214.  
  215.         if ( arg == DEFAULT )
  216.           PL_put_atom(av+0, ATOM_default);
  217.         else
  218.           PL_put_integer(av+0, arg);
  219.  
  220.         for(i=1; i<fdef->arity; i++)
  221.         { NEED_ARG;
  222.           PL_put_term(av+i, argv);
  223.           SHIFT;
  224.         }
  225.  
  226.         tellString(&str, BUFSIZE);
  227.         qid = PL_open_query(proc->definition->module, PL_Q_NODEBUG,
  228.                 proc, av);
  229.         PL_next_solution(qid);
  230.         PL_close_query(qid);
  231.         toldString();
  232.         OUTSTRING(str);
  233.         if ( str != buf )
  234.           free(str);
  235.  
  236.         fmt++;
  237.       } else
  238.       { switch(*fmt)        /* Build in formatting */
  239.         { case 'a':            /* atomic */
  240.         { char *s;
  241.  
  242.           NEED_ARG;
  243.           if ( !PL_get_chars(argv, &s, CVT_ATOMIC) )
  244.             ERROR("illegal argument to ~a");
  245.           SHIFT;
  246.           OUTSTRING(s);
  247.           fmt++;
  248.           break;
  249.         }
  250.           case 'c':            /* ascii */
  251.         { int c;
  252.  
  253.           NEED_ARG;
  254.           if ( PL_get_integer(argv, &c) && c>=0 && c<=255 )
  255.           { int times = (arg == DEFAULT ? 1 : arg);
  256.  
  257.             SHIFT;
  258.             while(times-- > 0)
  259.             { OUTCHR(c);
  260.             }
  261.           } else
  262.             ERROR("illegal argument to ~c");
  263.           fmt++;
  264.           break;
  265.         }
  266.           case 'e':            /* exponential float */
  267.           case 'E':            /* Exponential float */
  268.           case 'f':            /* float */
  269.           case 'g':            /* shortest of 'f' and 'e' */
  270.           case 'G':            /* shortest of 'f' and 'E' */
  271.         { double f;
  272.           char tmp[12];
  273.           char buf[256];
  274.  
  275.           NEED_ARG;
  276.           if ( !PL_get_float(argv, &f) )
  277.             ERROR1("illegal argument to ~%c", *fmt);
  278.           SHIFT;
  279.           Ssprintf(tmp, "%%.%d%c", arg == DEFAULT ? 6 : arg, *fmt);
  280.           Ssprintf(buf, tmp, f);
  281.           OUTSTRING(buf);
  282.           fmt++;
  283.           break;
  284.         }
  285.           case 'd':            /* integer */
  286.           case 'D':            /* grouped integer */
  287.           case 'r':            /* radix number */
  288.           case 'R':            /* Radix number */
  289.         { int i;
  290.           char tmp[50];
  291.  
  292.           NEED_ARG;
  293.           if ( !PL_get_integer(argv, &i) )
  294.             ERROR1("illegal argument to ~%c", *fmt);
  295.           SHIFT;
  296.           if ( arg == DEFAULT )
  297.             arg = 0;
  298.           if ( *fmt == 'd' || *fmt == 'D' )
  299.             formatInteger(*fmt == 'D', arg, 10, TRUE, i, tmp);
  300.           else
  301.             formatInteger(FALSE, 0, arg, *fmt == 'r', i, tmp);
  302.           OUTSTRING(tmp);            
  303.           fmt++;
  304.           break;
  305.         }
  306.           case 's':            /* string */
  307.         { char *s;
  308.  
  309.           NEED_ARG;
  310.           if ( !PL_get_chars(argv, &s, CVT_LIST|CVT_STRING) )
  311.             ERROR("illegal argument to ~s");
  312.           OUTSTRING(s);
  313.           SHIFT;
  314.           fmt++;
  315.           break;
  316.         }
  317.           case 'i':            /* ignore */
  318.         { NEED_ARG;
  319.           SHIFT;
  320.           fmt++;
  321.           break;
  322.         }
  323.         { Func f;
  324.           char buf[BUFSIZE];
  325.           char *str;
  326.  
  327.           case 'k':            /* write_canonical */
  328.           f = pl_write_canonical; 
  329.               goto pl_common;
  330.           case 'p':            /* print */
  331.           f = pl_print;
  332.               goto pl_common;
  333.           case 'q':            /* writeq */
  334.           f = pl_writeq;
  335.               goto pl_common;
  336.           case 'w':            /* write */
  337.           f = pl_write;
  338.           pl_common:
  339.  
  340.           NEED_ARG;
  341.           if ( pending_rubber )
  342.           { str = buf;
  343.             tellString(&str, BUFSIZE);
  344.             (*f)(argv);
  345.             toldString();
  346.             OUTSTRING(str);
  347.             if ( str != buf )
  348.               free(str);
  349.           } else
  350.           { IOSTREAM *s = PL_current_output();
  351.             if ( s->position && s->position->linepos == column )
  352.             { (*f)(argv);
  353.               column = s->position->linepos;
  354.             } else
  355.             { str = buf;
  356.               tellString(&str, BUFSIZE);
  357.               (*f)(argv);
  358.               toldString();
  359.               OUTSTRING(str);
  360.               if ( str != buf )
  361.             free(str);
  362.             }
  363.           }
  364.           SHIFT;
  365.           fmt++;
  366.           break;
  367.         }
  368.           case '~':            /* ~ */
  369.         { OUTCHR('~');
  370.           fmt++;
  371.           break;
  372.         }
  373.           case 'n':            /* \n */
  374.           case 'N':            /* \n if not on newline */
  375.         { if ( arg == DEFAULT )
  376.             arg = 1;
  377.           if ( *fmt == 'N' && column == 0 )
  378.             arg--;
  379.           while( arg-- > 0 )
  380.             OUTCHR('\n');
  381.           fmt++;
  382.           break;
  383.         }
  384.           case 't':            /* insert tab */
  385.         { rub[pending_rubber].where = index;
  386.           rub[pending_rubber].pad   = (arg == DEFAULT ? (Char) ' '
  387.                                   : (Char) arg);
  388.           pending_rubber++;
  389.           fmt++;
  390.           break;
  391.         }
  392.           case '|':            /* set tab */
  393.         { int stop;
  394.  
  395.           if ( arg == DEFAULT )
  396.             arg = column;
  397.           case '+':            /* tab relative */
  398.           if ( arg == DEFAULT )
  399.             arg = 8;
  400.           stop = (*fmt == '+' ? tab_stop + arg : arg);
  401.  
  402.           if ( pending_rubber == 0 ) /* nothing to distribute */
  403.           { rub[0].where = index;
  404.             rub[0].pad = ' ';
  405.             pending_rubber++;
  406.           }
  407.           distribute_rubber(rub, pending_rubber, stop - column);
  408.           emit_rubber(buffer, index, rub, pending_rubber);
  409.           index = 0;
  410.           pending_rubber = 0;
  411.  
  412.           column = tab_stop = stop;
  413.           fmt++;
  414.           break;
  415.         }
  416.           default:
  417.         ERROR1("unknown format: %c", *fmt);
  418.         }
  419.       }
  420.       break;            /* the '~' switch */
  421.     }
  422.       default:
  423.     { OUTCHR(*fmt);
  424.       fmt++;
  425.       break;
  426.     }
  427.     }
  428.   }
  429.  
  430.   if ( pending_rubber )            /* not closed ~t: flush out */
  431.     emit_rubber(buffer, index, rub, 0);
  432.  
  433.   UnlockStream();
  434.  
  435.   succeed;
  436. }
  437.  
  438. static void
  439. distribute_rubber(struct rubber *r, int rn, int space)
  440. { if ( space > 0 )
  441.   { int s = space / rn;
  442.     int n, m;
  443.  
  444.     for(n=0; n < rn; n++)        /* give them equal size */
  445.       r[n].size = s;
  446.                     /* distribute from the center */
  447.     space -= s*rn;
  448.     for(m = rn / 2, n = 0; space; n++, space--)
  449.     { r[m + (n % 2 ? n : -n)].size++;
  450.     }
  451.   } else
  452.   { int n;
  453.  
  454.     for(n=0; n < rn; n++)        /* set all rubber to 0 */
  455.       r[n].size = 0;
  456.   }
  457. }
  458.  
  459. static void
  460. emit_rubber(char *buf, int i, struct rubber *r, int rn)
  461. { int j;
  462.  
  463.   for(j = 0; j <= i; j++)
  464.   { if ( r->where == j && rn )
  465.     { int n;
  466.       for(n=0; n<r->size; n++)
  467.         Put(r->pad);
  468.       r++;
  469.       rn--;
  470.     }
  471.     if ( j < i )
  472.       Put(buf[j]);
  473.   }
  474. }
  475.